// index/pages/questionBankGoods/questionBankGoods.js
const { http } = require('../../../utils/http.js')
const { addPoints } = require('../../../utils/pointsService.js')

Page({

  data: {
    // 积分相关
    pointsEnabled: false,  // 默认不启用积分
    totalPoints: 0,        // 总积分
    usablePoints: 0,       // 可用积分
    maxUsablePoints: 0,    // 最高可用积分（限制100）
    pointsDeduction: 0,    // 积分抵扣金额
    
    // 价格相关
    originalPrice: 199.00,
    finalPrice: 189.00,
    
    // 支付方式
    selectedPayment: 'code', // 'code' 或 'wechat'
    
    // 商品信息
    productInfo: {
      title: '2024水利工程物理研究',
      duration: '365天',
      questionCount: 0,  // 动态获取题目数量
      tags: ['物理', '题库分类', '名词解释']
    },

    // 动态图片
    productImage: '/images/zxs01.jpg',
    productDescription: '',

    // 激活资源弹出窗
    showActivationModal: false,

    // 传入参数
    questionBankId: null,
    subjectId: null
  },

  /**
   * 获取用户积分信息
   */
  getUserPoints() {
    const userManager = require('../../../utils/userManager.js');
    const userId = userManager.getUserId();
    
    console.log('=== 开始获取用户积分 ===');
    console.log('用户ID:', userId);
    console.log('用户ID类型:', typeof userId);
    
    if (!userId) {
      console.log('用户未登录，无法获取积分');
      // 尝试从其他方式获取用户ID
      const userInfo = userManager.getCurrentUser();
      console.log('当前用户信息:', userInfo);
      
      if (userInfo && userInfo.userInfo) {
        console.log('从userInfo获取的字段:', Object.keys(userInfo.userInfo));
        console.log('userInfo.userId:', userInfo.userInfo.userId);
        console.log('userInfo.id:', userInfo.userInfo.id);
      }
      
      wx.showToast({
        title: '用户未登录',
        icon: 'none',
        duration: 1500
      });
      return;
    }
    
    console.log('请求接口: GET /points/profile/' + userId);
    console.log('完整请求URL:', `http://localhost:8080/points/profile/${userId}`);
    
    // 检查http工具是否正确导入
    console.log('http工具状态:', {
      http: http,
      httpType: typeof http,
      hasGet: !!http.get,
      hasRequest: !!http.request
    });
    
    // 调用积分接口
    try {
      http.get(`/points/profile/${userId}`)
        .then(res => {
          console.log('=== 积分接口返回数据 ===');
          console.log('完整响应对象:', res);
          console.log('响应类型:', typeof res);
          console.log('是否为数组:', Array.isArray(res));
          console.log('响应是否为null:', res === null);
          console.log('响应是否为undefined:', res === undefined);
          
          // 详细解析返回数据
          if (res && typeof res === 'object') {
            console.log('=== 响应数据详细解析 ===');
            console.log('所有字段名:', Object.keys(res));
            
            // 遍历所有字段
            Object.keys(res).forEach(key => {
              console.log(`字段: ${key} = ${res[key]} (类型: ${typeof res[key]})`);
            });
            
            // 尝试获取积分相关字段
            const possiblePointFields = ['totalPoints', 'points', 'total', 'usablePoints', 'availablePoints', 'usable', 'available', 'score', 'credit'];
            console.log('=== 可能的积分字段 ===');
            possiblePointFields.forEach(field => {
              if (res.hasOwnProperty(field)) {
                console.log(`找到积分字段: ${field} = ${res[field]}`);
              }
            });
            
            // 尝试获取其他可能的相关字段
            const otherFields = ['userId', 'user_id', 'id', 'username', 'userName', 'nickname', 'email', 'phone'];
            console.log('=== 其他相关字段 ===');
            otherFields.forEach(field => {
              if (res.hasOwnProperty(field)) {
                console.log(`找到相关字段: ${field} = ${res[field]}`);
              }
            });
            
                    // 更新页面数据（从data字段中获取积分信息）
        const data = res.data || res;
        const totalPoints = data.points || data.totalPoints || data.total || data.score || data.credit || 0;
        const usablePoints = data.usablePoints || data.availablePoints || data.usable || data.available || totalPoints || 0;
            
                    console.log('=== 解析后的积分数据 ===');
        console.log('从data字段获取的积分:', data.points);
        console.log('总积分:', totalPoints);
        console.log('可用积分:', usablePoints);
            
                    // 计算积分抵扣金额（10积分=1元），最高使用100积分
        const maxUsablePoints = Math.min(usablePoints, 100); // 限制最高使用100积分
        
        // 积分抵扣算法：10积分=1元，但需要考虑实际可用积分和商品价格
        let pointsDeduction = 0;
        if (maxUsablePoints > 0) {
          // 基础抵扣：每10积分抵扣1元
          const baseDeduction = maxUsablePoints / 10;
          
          // 确保抵扣金额不超过商品原价
          pointsDeduction = Math.min(baseDeduction, this.data.originalPrice);
          
          // 如果抵扣后价格过低，调整可用积分数量
          if (this.data.originalPrice - pointsDeduction < 0.01) {
            // 抵扣后价格接近0，调整积分使用量
            const adjustedPoints = Math.floor(this.data.originalPrice * 10);
            pointsDeduction = this.data.originalPrice;
            // 更新最高可用积分
            maxUsablePoints = Math.min(adjustedPoints, maxUsablePoints);
          }
        }
        
        console.log('积分抵扣计算详情:', {
          usablePoints: usablePoints,
          maxUsablePoints: maxUsablePoints,
          baseDeduction: maxUsablePoints / 10,
          finalDeduction: pointsDeduction,
          originalPrice: this.data.originalPrice
        });
        console.log('最高可用积分:', maxUsablePoints);
        console.log('计算出的抵扣金额:', pointsDeduction);
            
                    // 更新页面数据
        this.setData({
          totalPoints: totalPoints,
          usablePoints: usablePoints,
          maxUsablePoints: maxUsablePoints, // 最高可用积分（限制100）
          pointsDeduction: pointsDeduction
        });
            
                    console.log('=== 页面数据更新完成 ===');
        console.log('当前页面积分数据:', {
          totalPoints: this.data.totalPoints,
          usablePoints: this.data.usablePoints,
          maxUsablePoints: this.data.maxUsablePoints,
          pointsDeduction: this.data.pointsDeduction
        });
            
          } else {
            console.log('响应数据格式异常，不是对象类型');
            console.log('响应内容:', res);
          }
          
        })
        .catch(err => {
          console.error('=== 积分接口调用失败 ===');
          console.error('错误对象:', err);
          console.error('错误类型:', typeof err);
          console.error('错误信息:', err.message || err.msg || err);
          console.error('错误代码:', err.code || err.status || err.statusCode);
          
          if (err.response) {
            console.error('响应状态:', err.response.status);
            console.error('响应数据:', err.response.data);
          }
          
          // 如果获取失败，保持默认值
          wx.showToast({
            title: '获取积分失败',
            icon: 'none',
            duration: 1500
          });
        });
        
    } catch (error) {
      console.error('=== 调用积分接口时发生异常 ===');
      console.error('异常信息:', error);
      console.error('异常类型:', typeof error);
      console.error('异常堆栈:', error.stack);
      
      wx.showToast({
        title: '接口调用异常',
        icon: 'none',
        duration: 1500
      });
    }
  },

  /**
   * 切换积分使用
   */
  togglePoints(e) {
    const enabled = e.detail.value;
    
    if (enabled && this.data.usablePoints <= 0) {
      wx.showToast({
        title: '积分不足',
        icon: 'none'
      });
      return;
    }
    
    this.setData({
      pointsEnabled: enabled
    });
    
    // 重新计算最终价格
    this.recalculateFinalPrice();
    
    console.log('积分抵扣切换:', {
      enabled: enabled,
      originalPrice: this.data.originalPrice,
      pointsDeduction: this.data.pointsDeduction,
      finalPrice: this.data.finalPrice
    });
  },

  /**
   * 验证积分抵扣的合理性
   */
  validatePointsDeduction() {
    const { pointsEnabled, maxUsablePoints, pointsDeduction, originalPrice } = this.data;
    
    if (!pointsEnabled) {
      return { valid: true, message: '未启用积分抵扣' };
    }
    
    if (maxUsablePoints <= 0) {
      return { valid: false, message: '可用积分不足' };
    }
    
    if (pointsDeduction <= 0) {
      return { valid: false, message: '抵扣金额计算错误' };
    }
    
    if (pointsDeduction > originalPrice) {
      return { valid: false, message: '抵扣金额超过商品价格' };
    }
    
    // 验证积分使用量是否合理（每10积分抵扣1元）
    const expectedPoints = Math.ceil(pointsDeduction * 10);
    if (Math.abs(expectedPoints - maxUsablePoints) > 10) { // 允许10积分的误差
      console.warn('积分使用量与抵扣金额不匹配:', {
        expectedPoints,
        actualPoints: maxUsablePoints,
        pointsDeduction
      });
    }
    
    return { valid: true, message: '积分抵扣验证通过' };
  },

  /**
   * 重新计算最终价格
   */
  recalculateFinalPrice() {
    const { originalPrice, pointsEnabled, pointsDeduction } = this.data;
    let finalPrice = originalPrice;
    
    if (pointsEnabled && pointsDeduction > 0) {
      finalPrice = Math.max(0, originalPrice - pointsDeduction);
      // 确保价格不会为负数
      finalPrice = Math.max(0.01, finalPrice);
    }
    
    this.setData({ finalPrice });
    
    console.log('价格重新计算:', {
      originalPrice,
      pointsEnabled,
      pointsDeduction,
      finalPrice
    });
    
    return finalPrice;
  },

  /**
   * 处理积分扣除
   */
  async deductPoints() {
    if (!this.data.pointsEnabled || this.data.maxUsablePoints <= 0) {
      console.log('积分扣除跳过：未启用或积分不足');
      return { success: true, deductedPoints: 0 };
    }
    
    try {
      const pointsToDeduct = this.data.maxUsablePoints;
      const deductionAmount = this.data.pointsDeduction;
      
      console.log('=== 开始扣除积分 ===');
      console.log('扣除积分详情:', {
        pointsToDeduct: pointsToDeduct,
        deductionAmount: deductionAmount,
        productTitle: this.data.productInfo.title,
        questionBankId: this.data.questionBankId,
        userId: require('../../../utils/userManager.js').getUserId()
      });
      
      // 调用积分服务扣除积分
      const result = await addPoints(
        pointsToDeduct,  // 扣除的积分数量
        0,               // 0=减少积分
        `购买题库"${this.data.productInfo.title}"，积分抵扣¥${deductionAmount}`,
        '题库购买积分抵扣'
      );
      
      console.log('积分扣除成功:', result);
      
      // 扣除成功后，刷新用户积分信息
      this.getUserPoints();
      
      // 显示积分扣除成功提示
      wx.showToast({
        title: `积分抵扣成功，扣除${pointsToDeduct}积分`,
        icon: 'success',
        duration: 2000
      });
      
      return { success: true, deductedPoints: pointsToDeduct };
      
    } catch (error) {
      console.error('=== 积分扣除失败 ===');
      console.error('错误详情:', error);
      console.error('错误类型:', typeof error);
      console.error('错误信息:', error.message || error.msg || error);
      
      wx.showToast({
        title: '积分扣除失败，请联系客服',
        icon: 'none',
        duration: 3000
      });
      
      return { success: false, error: error.message || error.msg || '未知错误' };
    }
  },

  /**
   * 选择支付方式
   */
  selectPayment(e) {
    const paymentType = e.currentTarget.dataset.type
    this.setData({
      selectedPayment: paymentType
    })
  },

  /**
   * 查看会员
   */
  viewMembership() {
    wx.showModal({
      title: '会员详情',
      content: '开通会员可享受更多特权，包括免费学习所有资源、专属客服等',
      confirmText: '立即开通',
      cancelText: '稍后再说',
      success: (res) => {
        if (res.confirm) {
          wx.showToast({
            title: '会员功能开发中',
            icon: 'none'
          })
        }
      }
    })
  },

  /**
   * 确认购买
   */
  confirmPurchase() {
    // 验证积分抵扣
    const validation = this.validatePointsDeduction();
    if (!validation.valid) {
      wx.showToast({
        title: validation.message,
        icon: 'none',
        duration: 2000
      });
      return;
    }
    
    const paymentMethod = this.data.selectedPayment === 'code' ? '专属码兑换' : '微信支付'
    
    if (this.data.selectedPayment === 'code') {
      // 专属码兑换 - 显示激活资源弹出窗
      this.showActivationModal()
    } else {
      // 微信支付 - 显示确认购买弹窗
      const content = this.data.pointsEnabled 
        ? `确定要使用${paymentMethod}购买题库吗？\n原价：¥${this.data.originalPrice}\n积分抵扣：-¥${this.data.pointsDeduction}\n最终价格：¥${this.data.finalPrice}`
        : `确定要使用${paymentMethod}购买题库吗？\n最终价格：¥${this.data.finalPrice}`;
        
      wx.showModal({
        title: '确认购买',
        content: content,
        confirmText: '确认支付',
        cancelText: '取消',
        success: (res) => {
          if (res.confirm) {
            this.processPayment()
          }
        }
      })
    }
  },

  /**
   * 显示激活资源弹出窗
   */
  showActivationModal() {
    this.setData({
      showActivationModal: true
    })
  },

  /**
   * 隐藏激活资源弹出窗
   */
  hideActivationModal() {
    this.setData({
      showActivationModal: false
    })
  },

  /**
   * 确认激活
   */
  confirmActivation() {
    this.hideActivationModal()
    
    // 显示加载提示
    wx.showLoading({ title: '创建订单中...' })
    
    // 获取用户ID
    const userManager = require('../../../utils/userManager.js')
    const userId = userManager.getUserId()
    
    if (!userId) {
      wx.hideLoading()
      wx.showToast({ title: '用户未登录', icon: 'none' })
      return
    }
    
    // 组装订单数据
    const now = new Date()
    const orderNumber = `ORDER${Date.now()}`
    const payTime = now.toISOString().slice(0, 19).replace('T', ' ')
    
    const orderData = {
      userId: userId,
      questionBankId: this.data.questionBankId,
      orderNo: orderNumber,
      amount: Number(this.data.finalPrice).toFixed(2),
      points: this.data.pointsEnabled ? this.data.maxUsablePoints : 0,
      status: 'PAID',
      payTime: payTime
    }
    
    console.log('准备创建订单:', orderData)
    
    // 调用后端接口创建订单 - 只调用一次接口，避免重复
    http.post('/points/info', {
      ...orderData,
      businessType: 'INSERT',
      title: '订单管理'
    })
      .then((res) => {
        console.log('订单创建成功:', res)
        
        // 订单创建成功后，记录用户题库关联（暂时跳过后端关联，直接处理积分扣除）
        console.log('订单创建成功，准备处理积分抵扣')
        
        // 直接返回成功，跳过用户题库关联接口调用
        return Promise.resolve({ success: true, message: '订单创建成功' })
      })
      .then(async (associationRes) => {
        wx.hideLoading()
        console.log('用户题库关联创建成功:', associationRes)
        
        // 如果启用了积分抵扣，扣除积分
        if (this.data.pointsEnabled && this.data.maxUsablePoints > 0) {
          console.log('开始处理积分扣除...');
          const deductionResult = await this.deductPoints();
          
          if (!deductionResult.success) {
            wx.showToast({
              title: '积分扣除失败，请联系客服',
              icon: 'none',
              duration: 3000
            });
            return;
          }
          
          console.log('积分扣除完成:', deductionResult);
        }
        
        // 订单创建成功后，组装支付结果数据
        const paymentData = {
          amount: Number(this.data.finalPrice).toFixed(2),
          orderNumber: orderNumber,
          productName: this.data.productInfo.title,
          orderTime: payTime,
          paymentMethod: this.data.selectedPayment === 'code' ? '专属码兑换' : '微信支付',
          orderStatus: '已开通',
          questionBankId: this.data.questionBankId,
          subjectId: this.data.subjectId,
          // 新增字段
          userId: userId,
          points: orderData.points,
          orderNo: orderNumber,
          status: 'PAID',
          payTime: payTime
        }
        
        const encoded = encodeURIComponent(JSON.stringify(paymentData))
        
        // 跳转到支付结果页面
        wx.navigateTo({
          url: `/index/pages/paymentResult/paymentResult?paymentData=${encoded}`,
          success: () => {
            console.log('跳转到支付结果页面成功')
          },
          fail: (err) => {
            console.error('跳转失败:', err)
            wx.showToast({
              title: '跳转失败',
              icon: 'none',
              duration: 2000
            })
          }
        })
      })
      .catch(err => {
        wx.hideLoading()
        console.error('订单创建失败:', err)
        console.error('错误详情:', err)
        wx.showToast({
          title: '订单创建失败',
          icon: 'none',
          duration: 2000
        })
      })
  },

  /**
   * 联系客服
   */
  contactService() {
    wx.showModal({
      title: '联系客服',
      content: '客服电话：400-123-4567\n工作时间：9:00-18:00',
      confirmText: '拨打',
      cancelText: '取消',
      success: (res) => {
        if (res.confirm) {
          wx.makePhoneCall({
            phoneNumber: '400-123-4567',
            success: () => {
              console.log('拨打电话成功')
            },
            fail: (err) => {
              console.error('拨打电话失败:', err)
              wx.showToast({
                title: '拨打失败',
                icon: 'none'
              })
            }
          })
        }
      }
    })
  },

  /**
   * 阻止事件冒泡
   */
  stopPropagation() {
    // 阻止事件冒泡，防止点击弹窗内容时关闭弹窗
    return
  },

  /**
   * 处理支付
   */
  processPayment() {
    wx.showLoading({
      title: '支付中...'
    })
    
    // 模拟支付过程
    setTimeout(() => {
      wx.hideLoading()
      
      if (this.data.selectedPayment === 'code') {
        // 专属码兑换流程
        wx.showModal({
          title: '请输入专属码',
          editable: true,
          placeholderText: '请输入您的专属兑换码',
          success: (res) => {
            if (res.confirm && res.content) {
              this.handleCodeRedemption(res.content)
            }
          }
        })
      } else {
        // 微信支付流程
        this.handleWechatPayment()
      }
    }, 1000)
  },

  /**
   * 处理专属码兑换
   */
  handleCodeRedemption(code) {
    if (!code || code.trim() === '') {
      wx.showToast({
        title: '请输入激活码',
        icon: 'none'
      })
      return
    }
    
    wx.showLoading({
      title: '验证激活码中...'
    })
    
    // 获取用户ID
    const userManager = require('../../../utils/userManager.js')
    const userId = userManager.getUserId()
    
    if (!userId) {
      wx.hideLoading()
      wx.showToast({ title: '用户未登录', icon: 'none' })
      return
    }
    
    // 这里可以调用激活码验证接口
    // 暂时模拟验证过程
    setTimeout(() => {
      wx.hideLoading()
      
      // 模拟激活码验证成功
      const isValidCode = true // 这里应该调用后端验证接口
      
      if (isValidCode) {
        wx.showToast({
          title: '激活码验证成功！',
          icon: 'success',
          duration: 2000
        })
        
        // 激活码验证成功后，创建订单
        this.createOrderAfterCodeValidation(userId, code)
      } else {
        wx.showToast({
          title: '激活码无效',
          icon: 'none',
          duration: 2000
        })
      }
    }, 1500)
  },
  
  /**
   * 激活码验证成功后创建订单
   */
  createOrderAfterCodeValidation(userId, activationCode) {
    wx.showLoading({ title: '创建订单中...' })
    
    // 组装订单数据
    const now = new Date()
    const orderNumber = `ORDER${Date.now()}`
    const payTime = now.toISOString().slice(0, 19).replace('T', ' ')
    
    const orderData = {
      userId: userId,
      questionBankId: this.data.questionBankId,
      orderNo: orderNumber,
      amount: 0, // 激活码兑换，金额为0
      points: 0, // 激活码兑换，不使用积分
      status: 'PAID', // 激活码兑换，直接支付成功
      payTime: payTime,
      activationCode: activationCode // 记录使用的激活码
    }
    
    console.log('准备创建激活码兑换订单:', orderData)
    
    // 调用后端接口创建订单 - 只调用一次接口，避免重复
    http.post('/points/info', {
      ...orderData,
      businessType: 'INSERT',
      title: '订单管理'
    })
      .then((res) => {
        console.log('激活码兑换订单创建成功:', res)
        
        // 订单创建成功后，记录用户题库关联（暂时跳过后端关联，直接处理积分扣除）
        console.log('激活码兑换订单创建成功，准备跳转支付结果页面')
        
        // 直接返回成功，跳过用户题库关联接口调用
        return Promise.resolve({ success: true, message: '激活码兑换订单创建成功' })
      })
      .then((associationRes) => {
        wx.hideLoading()
        console.log('用户题库关联创建成功:', associationRes)
        
        // 订单创建成功后，跳转到支付结果页面
        const paymentData = {
          amount: '0.00',
          orderNumber: orderNumber,
          productName: this.data.productInfo.title,
          orderTime: payTime,
          paymentMethod: '专属码兑换',
          orderStatus: '已开通',
          questionBankId: this.data.questionBankId,
          subjectId: this.data.subjectId,
          userId: userId,
          points: 0,
          orderNo: orderNumber,
          status: 'PAID',
          payTime: payTime,
          activationCode: activationCode
        }
        
        const encoded = encodeURIComponent(JSON.stringify(paymentData))
        
        wx.navigateTo({
          url: `/index/pages/paymentResult/paymentResult?paymentData=${encoded}`,
          success: () => {
            console.log('跳转到支付结果页面成功')
          },
          fail: (err) => {
            console.error('跳转失败:', err)
            wx.showToast({
              title: '跳转失败',
              icon: 'none',
              duration: 2000
            })
          }
        })
      })
      .catch(err => {
        wx.hideLoading()
        console.error('激活码兑换订单创建失败:', err)
        console.error('错误详情:', err)
        wx.showToast({
          title: '订单创建失败',
          icon: 'none',
          duration: 2000
        })
      })
  },

  /**
   * 处理微信支付
   */
  handleWechatPayment() {
    // 显示加载提示
    wx.showLoading({ title: '创建订单中...' })
    
    // 获取用户ID
    const userManager = require('../../../utils/userManager.js')
    const userId = userManager.getUserId()
    
    if (!userId) {
      wx.hideLoading()
      wx.showToast({ title: '用户未登录', icon: 'none' })
      return
    }
    
    // 组装订单数据
    const now = new Date()
    const orderNumber = `ORDER${Date.now()}`
    const payTime = now.toISOString().slice(0, 19).replace('T', ' ')
    
    const orderData = {
      userId: userId,
      questionBankId: this.data.questionBankId,
      orderNo: orderNumber,
      amount: Number(this.data.finalPrice).toFixed(2),
      points: this.data.pointsEnabled ? this.data.maxUsablePoints : 0,
      status: 'PENDING', // 微信支付待支付状态
      payTime: payTime
    }
    
    console.log('准备创建微信支付订单:', orderData)
    
    // 调用后端接口创建订单 - 只调用一次接口，避免重复
    http.post('/points/info', {
      ...orderData,
      businessType: 'INSERT',
      title: '订单管理'
    })
      .then((res) => {
        console.log('微信支付订单创建成功:', res)
        
        // 订单创建成功后，记录用户题库关联（暂时跳过后端关联，直接处理积分扣除）
        console.log('微信支付订单创建成功，准备处理积分抵扣')
        
        // 直接返回成功，跳过用户题库关联接口调用
        return Promise.resolve({ success: true, message: '微信支付订单创建成功' })
      })
      .then(async (associationRes) => {
        wx.hideLoading()
        console.log('用户题库关联创建成功:', associationRes)
        
        // 如果启用了积分抵扣，扣除积分
        if (this.data.pointsEnabled && this.data.maxUsablePoints > 0) {
          console.log('开始处理积分扣除...');
          const deductionResult = await this.deductPoints();
          
          if (!deductionResult.success) {
            wx.showToast({
              title: '积分扣除失败，请联系客服',
              icon: 'none',
              duration: 3000
            });
            return;
          }
          
          console.log('积分扣除完成:', deductionResult);
        }
        
        // 这里可以调用微信支付API
        // 暂时显示成功提示
        wx.showToast({
          title: '订单创建成功，微信支付功能开发中',
          icon: 'success',
          duration: 2000
        })
        
        // 延迟跳转到支付结果页面
        setTimeout(() => {
          const paymentData = {
            amount: Number(this.data.finalPrice).toFixed(2),
            orderNumber: orderNumber,
            productName: this.data.productInfo.title,
            orderTime: payTime,
            paymentMethod: '微信支付',
            orderStatus: '待支付',
            questionBankId: this.data.questionBankId,
            subjectId: this.data.subjectId,
            userId: userId,
            points: orderData.points,
            orderNo: orderNumber,
            status: 'PENDING',
            payTime: payTime
          }
          
          const encoded = encodeURIComponent(JSON.stringify(paymentData))
          
          wx.navigateTo({
            url: `/index/pages/paymentResult/paymentResult?paymentData=${encoded}`,
            success: () => {
              console.log('跳转到支付结果页面成功')
            },
            fail: (err) => {
              console.error('跳转失败:', err)
              wx.showToast({
                title: '跳转失败',
                icon: 'none',
                duration: 2000
              })
            }
          })
        }, 2000)
      })
      .catch(err => {
        wx.hideLoading()
        console.error('微信支付订单创建失败:', err)
        console.error('错误详情:', err)
        wx.showToast({
          title: '订单创建失败',
          icon: 'none',
          duration: 2000
        })
      })
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    console.log('题库购买页面加载', options)
    const { questionBankId, subjectId } = options || {}
    
    if (questionBankId) {
      this.setData({
        questionBankId: isNaN(Number(questionBankId)) ? questionBankId : Number(questionBankId),
        subjectId: subjectId !== undefined ? (isNaN(Number(subjectId)) ? subjectId : Number(subjectId)) : null
      })
      console.log('接收参数 -> 题库ID:', questionBankId, '科目ID:', subjectId)
      // 根据题库ID加载商品/题库信息
      this.loadProductInfo(questionBankId, subjectId)
      this.fetchQuestionBankDetail(questionBankId)
    } else {
      wx.showToast({
        title: '缺少题库ID',
        icon: 'none'
      })
    }
  },

  /**
   * 加载商品信息
   */
  loadProductInfo(productId, subjectId) {
    // 这里可以调用API获取商品详情
    console.log('加载商品信息 -> 题库ID:', productId, '科目ID:', subjectId)
  },

  /**
   * 拉取题库详情
   */
  fetchQuestionBankDetail(id) {
    wx.showLoading({ title: '加载详情...' })
    http.get(`/fk/question_bank/${id}`)
      .then(res => {
        wx.hideLoading()
        const payload = res && res.data ? res.data : res
        console.log('题库详情返回:', payload)
        if (!payload) {
          wx.showToast({ title: '未获取到详情', icon: 'none' })
          return
        }
        const title = payload.name || this.data.productInfo.title
        const img = payload.url
        const tags = []
        if (payload.subjectName) tags.push(payload.subjectName)
        if (payload.type) tags.push(payload.type)
        if (payload.description) tags.push('简介')

        // 获取题目数量（尝试多种可能的字段名）
        const questionCount = payload.questionCount || payload.questionNum || payload.totalQuestions || payload.questions || 0
        console.log('获取到的题目数量:', questionCount)

        // 设置价格
        const price = Number(payload.price) || this.data.originalPrice

        this.setData({
          productInfo: {
            ...this.data.productInfo,
            title,
            questionCount: questionCount,  // 更新题目数量
            tags: tags.length ? tags : this.data.productInfo.tags
          },
          productImage: img,
          productDescription: payload.description || '',
          originalPrice: price
        })
        
        // 重新计算最终价格（考虑积分抵扣）
        this.recalculateFinalPrice();

        // 如果题库详情接口没有返回题目数量，调用题目接口获取详细信息
        if (!questionCount || questionCount === 0) {
          console.log('题库详情接口未返回题目数量，调用题目接口获取详细信息')
          this.fetchQuestionCount(id)
        } else {
          console.log('题库详情接口已返回题目数量:', questionCount)
        }
      })
      .catch(err => {
        wx.hideLoading()
        console.error('获取题库详情失败:', err)
        wx.showToast({ title: '加载失败', icon: 'none' })
      })
  },

  /**
   * 获取题库题目数量和详细信息
   */
  fetchQuestionCount(bankId) {
    console.log('开始获取题库题目信息，题库ID:', bankId)
    
    // 使用项目提供的完整接口
    http.get(`/fk/question_bank/questions/${bankId}`)
      .then(res => {
        const payload = res && res.data ? res.data : res
        console.log('题库题目接口返回:', payload)
        
        if (payload && Array.isArray(payload)) {
          const questionCount = payload.length
          console.log('获取到题目数量:', questionCount)
          console.log('题目详细信息:', payload)
          
          // 更新题目数量
          this.setData({
            'productInfo.questionCount': questionCount
          })
          
          // 可以进一步处理题目信息，比如获取题目类型分布、难度分布等
          this.processQuestionDetails(payload)
          
        } else if (payload && Array.isArray(payload.content)) {
          // 如果返回的是分页格式 {content: [], totalElements: 100}
          const questionCount = payload.totalElements || payload.content.length
          console.log('分页格式获取到题目数量:', questionCount)
          
          this.setData({
            'productInfo.questionCount': questionCount
          })
          
          this.processQuestionDetails(payload.content)
          
        } else {
          console.log('接口返回格式异常，无法获取题目数量')
        }
      })
      .catch(err => {
        console.error('获取题库题目信息失败:', err)
        console.log('无法获取题目数量，使用默认值')
      })
  },

  /**
   * 处理题目详细信息
   */
  processQuestionDetails(questions) {
    if (!questions || !Array.isArray(questions) || questions.length === 0) {
      return
    }
    
    console.log('开始处理题目详细信息')
    
    // 统计题目类型分布
    const typeStats = {}
    // 统计难度分布
    const difficultyStats = {}
    // 获取题目图片数量
    let imageCount = 0
    
    questions.forEach(question => {
      // 统计题目类型
      if (question.type) {
        typeStats[question.type] = (typeStats[question.type] || 0) + 1
      }
      
      // 统计难度
      if (question.difficulty) {
        difficultyStats[question.difficulty] = (difficultyStats[question.difficulty] || 0) + 1
      }
      
      // 统计有图片的题目
      if (question.imageUrl || question.image || question.url) {
        imageCount++
      }
    })
    
    console.log('题目类型分布:', typeStats)
    console.log('题目难度分布:', difficultyStats)
    console.log('有图片的题目数量:', imageCount)
    
    // 更新页面显示题目统计信息
    this.setData({
      'productInfo.typeStats': typeStats,
      'productInfo.difficultyStats': difficultyStats,
      'productInfo.imageCount': imageCount
    })
  },

  /**
   * 测试积分抵扣功能
   */
  testPointsDeduction() {
    console.log('=== 测试积分抵扣功能 ===');
    console.log('当前积分状态:', {
      pointsEnabled: this.data.pointsEnabled,
      totalPoints: this.data.totalPoints,
      usablePoints: this.data.usablePoints,
      maxUsablePoints: this.data.maxUsablePoints,
      pointsDeduction: this.data.pointsDeduction,
      originalPrice: this.data.originalPrice,
      finalPrice: this.data.finalPrice
    });
    
    // 验证积分抵扣
    const validation = this.validatePointsDeduction();
    console.log('积分抵扣验证结果:', validation);
    
    // 重新计算价格
    const newPrice = this.recalculateFinalPrice();
    console.log('重新计算后的价格:', newPrice);
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {
    // 页面渲染完成后，可以在这里添加一些初始化逻辑
    console.log('页面渲染完成，积分抵扣功能已就绪');
  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    console.log('=== questionBankGoods 页面显示 ===');
    // 获取用户ID并调用积分接口
    this.getUserPoints();
    
    // 延迟一下再测试积分抵扣功能，确保数据已加载
    setTimeout(() => {
      this.testPointsDeduction();
    }, 1000);
  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {

  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {

  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {

  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {

  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {

  }
})